package com.tjtt.common.utils;

import java.sql.Timestamp;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.apache.log4j.Logger;
 

public class ValidateUtil {
	private static Logger logger = Logger.getLogger(ValidateUtil.class);
	
	/**
	 * 检查字符串是否是整数类型 通过校验，返回整形对象，否则返回null
	 * 
	 * @param value
	 * @return Integer
	 */
	public static Integer checkInt(String value) {
		Integer returnValue = null;
		try {
			int temp = Integer.parseInt(value);
			returnValue = new Integer(temp);
		} catch (NumberFormatException e) {
			logger.error(e);
		}
		return returnValue;
	}

	/**
	 * 检查字符串可否转化为Double型，并且小数位为两位 通过校验，返回Double对象，否则返回null
	 * 
	 * @param value
	 * @return Double
	 */
	public static Double checkDouble(String value) {
		Double returnValue = null;
		if (value != null && !value.equals("")) {
			int length = value.length();
			int index = value.indexOf('.');
			if (index == -1 || (index != -1 && (length - index) <= 3))
				try {
					double temp = Double.parseDouble(value);
					returnValue = new Double(temp);
				} catch (NumberFormatException e) {
					System.out.println("check execption!");
				}
		}
		return returnValue;
	}

	public static Double String2Double(String value) {
		Double result = null;
		if (value == null || value.equals("")) {
			value = "0";
		}

		try {
			double temp = Double.parseDouble(value);
			result = new Double(temp);
		} catch (NumberFormatException e) {
			System.out.println("parse execption!");
		}

		return result;
	}

	/**
	 * 检测..
	 * 
	 * @param value
	 * @return Integer
	 */
	public static Integer checkIntNull(String value) {
		Integer result = new Integer(0);
		try {
			if (!(value == null || value.equals(""))) {
				result = new Integer(value);
			}
		} catch (NumberFormatException e) {
			logger.error(e);
		}
		return result;
	}

	/**
	 * 检查字符串是否是日期类型 通过校验，返回日期对象，否则返回null
	 * 
	 * @param date
	 * @param pattern
	 * @return Date
	 */
	public static Date checkDate(String date, String pattern) {

		// 如果模型为空，设置默认模型
		if (StringUtil.isNull(pattern)) {
			pattern = "yyyyMMdd";
		}

		// 返回日期
		Date realDate = null;
		try {
			// 模型为"yyyyMMdd"时，看输入的日期是否由8位数字拼成
			if (pattern.equals("yyyyMMdd") && !checkString_Num(date, 8)) {
				realDate = null;
			} else {
				// 得到格式化日期的工具类，解析该串，看是否为有效日期
				DateFormat sdf = new SimpleDateFormat(pattern);
				// 严格校验
				sdf.setLenient(false);

				realDate = sdf.parse(date);
			}
		}

		catch (Exception e) {
			logger.error("this string is not a Date");
			realDate = null;
		}

		return realDate;
	}

	/**
	 * 检查字符串是否是合法日期 通过校验，返回TimeStamp对象，否则返回null（供数据库操作使用）
	 * 
	 * @param date
	 * @return Timestamp
	 */
	public static Timestamp checkTimestamp(String date, String pattern) {
		Date realDate = checkDate(date, pattern);
		return (realDate == null ? null : new Timestamp(realDate.getTime()));
	}

	/**
	 * 检查日期是否在当前日期之后（包括当前日期），且格式正确，否则返回null
	 * 
	 * @param date
	 * @param pattern
	 * @return Date
	 */
	public static String checkAfterCurDate(String date, String pattern) {

		// 先检验日期格式是否正确
		Date realDate = checkDate(date, pattern);

		// 如果日期格式不正确，或者在当前日期之前，则返回null
		if ((realDate == null) || realDate.compareTo(new Date()) < 0) {
			date = null;
		}
		return date;
	}

	/**
	 * 检查日期是否在当前日期之前（包括当前日期），且格式正确，否则返回null
	 * 
	 * @param date
	 * @param pattern
	 * @return Date
	 */
	public static String checkBeforeCurDate(String date, String pattern) {

		// 待检查日期为空时，返回null
		if (StringUtil.isNull(date)) {
			return null;
		}
		// 先检验日期格式是否正确
		Date realDate = checkDate(date, pattern);

		// 如果日期格式不正确，或者在当前日期之后，则返回null
		if ((realDate == null) || realDate.compareTo(new Date()) > 0) {
			date = null;
		}
		return date;
	}

	/**
	 * 检查某日期是否是20天之前的日期，以字符串比较的，格式"yyyyMMdd"
	 * 
	 * @param startDate
	 * @param endDate
	 * @return int
	 */
	public static int calDateArea(String startDate, String endDate) {
		// 取得当前时间
		Calendar cal = Calendar.getInstance();
		// 当前日期
		// String curStr = StringUtil.getDateString(cal.getTime(),"yyyyMMdd");
		// 前二十天时间值
		cal.add(Calendar.DATE, -20);
		// 前二十天日期
		// String criticalDate = StringUtil.getDateString(cal.getTime(),
		// "yyyyMMdd");
		// 由于表中数据太不规范，只能权且这样设置
		String criticalDate = "20030401";

		// 跨越两个时间段
		if (startDate.compareTo(criticalDate) <= 0
				&& endDate.compareTo(criticalDate) > 0) {
			return 0;
		}
		// 在20天之前的时间段
		else if (startDate.compareTo(criticalDate) <= 0
				&& endDate.compareTo(criticalDate) <= 0) {
			return -1;
		}
		// 在20天之中的时间段
		else if (startDate.compareTo(criticalDate) > 0
				&& endDate.compareTo(criticalDate) > 0) {
			return 1;
		}
		// 错误日期代码
		else {
			return -2;
		}
	}
	
	/**
	 * 比较两个日期间隔，返回long类型的间隔天数，以字符串比较的，格式"yyyyMMdd"
	 * 
	 * @param startDate
	 * @param endDate
	 * @return long
	 * @throws ParseException 
	 */
	public static long compare(String startDate, String endDate) throws ParseException{		
		SimpleDateFormat formatter = new SimpleDateFormat("yyyyMMdd");
		Date d1 = formatter.parse(startDate);
		Date d2 = formatter.parse(endDate);
		long diff = d2.getTime() - d1.getTime();
		return (diff/(1000*60*60*24));
	}
	
	/**
	 * 比较输入的日期和系统当前日期间隔，返回long类型的间隔天数，以字符串比较的，格式"yyyyMMdd"
	 * 
	 * @param startDate
	 * @param endDate
	 * @return long
	 * @throws ParseException 
	 */
	public static long compare(String startDate) throws ParseException{		
		SimpleDateFormat formatter = new SimpleDateFormat("yyyyMMdd");
		Date d1 = formatter.parse(startDate);
		Date d2 = new Date();
		long diff = d1.getTime() - d2.getTime();
		return (diff/(1000*60*60*24));
	}

	/**
	 * 取字符串的子串（截取前几位） 如果可以取到，则返回结果；否则返回null
	 * 
	 * @param str
	 *            原串
	 * @param n
	 *            字串位数
	 * @return String
	 */
	public static String getSubstring(String str, int n) {
		// 先检验参数
		if (str == null || str.length() < n || n <= 0) {
			return null;
		}
		return str.substring(0, n);
	}

	/**
	 * 校验两个字符串是否相等（长度大于1） 通过校验，返回结果，相等返回true，否则返回false
	 * 
	 * @param str1
	 *            String
	 * @param str2
	 *            String
	 * @return boolean
	 */

	public static boolean isEqual(String str1, String str2) {
		// 两个字符串不能为空，长度要大于1,并且相等
		return (!StringUtil.isEmpty(str1) && !StringUtil.isEmpty(str1) && str1
				.equals(str2));
	}

	/**
	 * checkout if the idcard number is valid the checks below are applied:
	 * <ul>
	 * <li>check if the card number is empty
	 * <li>check if the card number's length is 15 or 18
	 * <li>if the card number's length is 18, check the number is compliance
	 * with the GB 11643-1999
	 * </ul>
	 * 
	 * Appendix: GB 11643-1999<br>
	 * 根据〖中华人民共和国国家标准 GB 11643-1999〗中有关公民身份号码的规定，<br>
	 * 公民身份号码是特征组合码，由十七位数字本体码和一位数字校验码组成。<br>
	 * 排列顺序从左至右依次为：六位数字地址码，八位数字出生日期码，三位数字顺序码和一位数字校验码。<br>
	 * 地址码表示编码对象常住户口所在县(市、旗、区)的行政区划代码。<br>
	 * 生日期码表示编码对象出生的年、月、日，其中年份用四位数字表示，年、月、日之间不用分隔符。<br>
	 * 顺序码表示同一地址码所标识的区域范围内，对同年、月、日出生的人员编定的顺序号。<br>
	 * 顺序码的奇数分给男性，偶数分给女性。<br>
	 * 校验码是根据前面十七位数字码，按照ISO 7064:1983.MOD 11-2校验码计算出来的检验码。<br>
	 * 下面举例说明该计算方法。<br>
	 * 15位的身份证编码首先把出生年扩展为4位，简单的就是增加一个19，但是这对于1900年出生的人不使用<br>
	 * 某男性公民身份号码本体码为34052419800101001，首先按照公式⑴计算：<br>
	 * ∑(ai×Wi)(mod 11)……………………………………(1)<br>
	 * 公式(1)中：<br>
	 * i----表示号码字符从由至左包括校验码在内的位置序号；<br>
	 * ai----表示第i位置上的号码字符值；<br>
	 * Wi----示第i位置上的加权因子，其数值依据公式Wi=2（n-1）(mod 11)计算得出。<br>
	 * i 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1<br>
	 * ai 3 4 0 5 2 4 1 9 8 0 0 1 0 1 0 0 1 a1<br>
	 * Wi 7 9 10 5 8 4 2 1 6 3 7 9 10 5 8 4 2 1<br>
	 * ai×Wi 21 36 0 25 16 16 2 9 48 0 0 9 0 5 0 0 2 a1<br>
	 * 根据公式(1)进行计算：<br>
	 * ∑(ai×Wi) =（21+36+0+25+16+16+2+9+48++0+0+9+0+5+0+0+2) = 189<br>
	 * 189 ÷ 11 = 17 + 2/11<br>
	 * ∑(ai×Wi)(mod 11) = 2<br>
	 * 然后根据计算的结果，从下面的表中查出相应的校验码，其中X表示计算结果为10：<br>
	 * ∑(ai×WI)(mod 11) 0 1 2 3 4 5 6 7 8 9 10<br>
	 * 校验码字符值ai 1 0 X 9 8 7 6 5 4 3 2<br>
	 * 根据上表，查出计算结果为2的校验码为所以该人员的公民身份号码应该为 34052419800101001X<br>
	 * 
	 * @param idCardNumber
	 *            String id card number
	 * @return String
	 */
	public static String checkIDCardNumber(String idCardNumber) {
		// 号码为空或长度不为15或18，无效，返回null
		if (StringUtil.isNull(idCardNumber)
				|| (idCardNumber.length() != 15 && idCardNumber.length() != 18)) {
			idCardNumber = null;
		} else {
			if (idCardNumber.length() == 15) {
				try {
					Long.parseLong(idCardNumber);
					idCardNumber = idCardNumber.substring(0, 6) + "19"
							+ idCardNumber.substring(6);
					idCardNumber += getCheckCodeOfIDNumber(idCardNumber);
				} catch (Exception ex) {
					idCardNumber = null;
				}
			} else {
				// number's length is 18
				String id17 = idCardNumber.substring(0, 17);
				String key = getCheckCodeOfIDNumber(id17);
				if (!(id17 + key).equals(idCardNumber)) {
					idCardNumber = null;
				}
			}
		}
		return idCardNumber;
	}

	/**
	 * get the check code of the id card number
	 * 
	 * @param id17
	 *            String id card number
	 * @return String check code
	 */
	private static String getCheckCodeOfIDNumber(String id17) {
		String key = "";
		int tempkey = 0;
		for (int i = 18; i > 1; i--) {
			tempkey += (int) Math.pow(2, i - 1) % 11
					* Integer.valueOf("" + id17.charAt(18 - i)).intValue();
		}
		tempkey %= 11;
		switch (tempkey) {
		case 0:
			key = "1";
			break;
		case 1:
			key = "0";
			break;
		case 2:
			key = "x";
			break;
		default:
			key = 12 - tempkey + "";
			break;
		}
		return key;
	}

	/**
	 * 判断字符串是否是字母或数字组成的串
	 * 
	 * @param str
	 * @return boolean
	 */
	// public static boolean checkString_LetOrNum(String str) {
	// if (str == null) {
	// return false;
	// }
	// Pattern p = Pattern.compile("[a-zA-Z0-9]+");
	// Matcher m = p.matcher(str);
	// return m.matches();
	//
	// }
	/**
	 * 判断字符串是否是字母或数字组成的length位串
	 * 
	 * @param str
	 * @param length
	 *            串的长度
	 * @return boolean
	 */
	public static boolean checkString_LetOrNum(String str, int length) {
		if (str == null) {
			return false;
		}
		// 默认位数不限
		String style = "[a-zA-Z0-9]+";
		if (length > 0) {
			style = "[a-zA-Z0-9]{" + length + "}";
		}
		Pattern p = Pattern.compile(style);
		Matcher m = p.matcher(str);
		return m.matches();
	}

	/**
	 * 判断字符串是否是字母组成串
	 * 
	 * @param str
	 * @return boolean
	 */
	public static boolean checkString_Let(String str) {
		if (str == null) {
			return false;
		}
		Pattern p = Pattern.compile("[a-zA-Z]+");
		Matcher m = p.matcher(str);
		return m.matches();
	}

	/**
	 * 判断字符串是否是i位数字组成串，用于第一步过滤日期，格式为"yyyyMMdd"
	 * 
	 * @param str
	 * @return boolean
	 */
	public static boolean checkString_Num(String str, int i) {
		if (StringUtil.isNull(str)) {
			return false;
		}
		str = str.trim();
		String pattern = "[0-9]";
		if (i <= 0) {
			pattern += "+";
		} else {
			pattern += "{" + i + "}";
		}
		Pattern p = Pattern.compile(pattern);
		Matcher m = p.matcher(str);
		return m.matches();
	}

	/**
	 * 验证是否大于等于当前年度
	 * 
	 * @param year
	 * @return
	 */
	public static boolean checkAfterCurYear(String year) {
		if (StringUtil.isNull(year) || !checkString_Num(year, 4)) {
			return false;
		}
		String curYear = getCurYear();

		if (StringUtil.isNull(curYear) || curYear.compareTo(year) > 0) {
			return false;
		}
		return true;
	}

	/**
	 * 验证是否小于等于当前日期
	 * 
	 * @param date
	 * @return
	 */
	public static boolean checkAfterCurDate(String date) {
		if (StringUtil.isNull(date) || !checkString_Num(date, 8)) {
			return false;
		}
		String curDate = getCurDate(null);

		if (StringUtil.isNull(curDate) || curDate.compareTo(date) < 0) {
			return false;
		}
		return true;
	}

	/**
	 * 验证截止日期是否大于等于起始日期
	 * 
	 * @param year
	 * @return
	 */
	public static boolean checkDateTurn(String first, String last) {
		if (StringUtil.isNull(first) || !checkString_Num(first, 8)
				|| StringUtil.isNull(last) || !checkString_Num(last, 8)) {
			return false;
		}
		if (last.compareTo(first) < 0) {
			return false;
		}
		return true;
	}

	/**
	 * 取得当前日期(年月日)，格式pattern指定，默认为"yyyyMMdd"
	 * 
	 * @param pattern
	 * @return
	 */
	public static String getCurDate(String pattern) {
		// 取得当前日期
		Calendar cal = Calendar.getInstance();
		String formatString = null;
		if (StringUtil.isNull(pattern)) {
			// 默认格式
			pattern = "yyyyMMdd";
		}

		// 格式化日期
		try {
			DateFormat df = new SimpleDateFormat(pattern);
			formatString = df.format(cal.getTime());
		} catch (Throwable t) {
			// pattern不符合规定
			logger.error("pattern of format date is invalid", t);
		}

		// 返回格式化的字符串
		return formatString;
	}
	
	public static String getCurDate(String pattern,Date date) {
		String formatString = null;
		if (StringUtil.isNull(pattern)) {
			// 默认格式
			pattern = "yyyyMMdd";
		}

		// 格式化日期
		try {
			DateFormat df = new SimpleDateFormat(pattern);
			formatString = df.format(date);
		} catch (Throwable t) {
			// pattern不符合规定
			logger.error("pattern of format date is invalid", t);
		}

		// 返回格式化的字符串
		return formatString;
	}

	/**
	 * 取得当前年度，四位
	 * 
	 * @param pattern
	 * @return
	 */
	public static String getCurYear() {
		// 取得当前日期
		Calendar cal = Calendar.getInstance();
		String curYear = null;

		// 格式化日期
		try {
			DateFormat df = new SimpleDateFormat("yyyy");
			curYear = df.format(cal.getTime());
		} catch (Throwable t) {
			// pattern不符合规定
			logger.error("pattern of format date is invalid", t);
		}

		// 返回格式化的字符串
		return curYear;
	}

	/**
	 * 取得下一年度，四位
	 * 
	 * @param pattern
	 * @return
	 */
	public static String getNextYear() {
		String nextYear = null;

		// 格式化日期
		try {
			DateFormat df = new SimpleDateFormat("yyyy");
			// 取得当前年
			int curYear = Integer.parseInt(df.format(new Date(System
					.currentTimeMillis())));
			nextYear = new Integer((curYear) + 1).toString();
		} catch (Throwable t) {
			// pattern不符合规定
			logger.error("pattern of format date is invalid", t);
		}

		// 返回格式化的字符串
		return nextYear;
	}

	/**
	 * 取得当前年度，四位
	 * 
	 * @param pattern
	 * @return
	 */
	public static String getCurrYear() {

		String nextYear = null;
		// 格式化日期
		try {
			DateFormat df = new SimpleDateFormat("yyyy");
			// 取得当前年
			int curYear = Integer.parseInt(df.format(new Date(System
					.currentTimeMillis())));
			return String.valueOf(curYear);
		} catch (Throwable t) {
			// pattern不符合规定
			logger.error("pattern of format date is invalid", t);
		}

		// 返回格式化的字符串
		return nextYear;
	}

	/**
	 * 取得当前时间(年月日时分秒)，格式pattern指定，默认为"yyyyMMdd HHmmss"
	 * 
	 * @param pattern
	 * @return
	 */
	public static String getCurTime(String pattern) {
		// 取得当前系统时间
		Calendar cal = Calendar.getInstance();
		String formatString = null;
		if (StringUtil.isNull(pattern)) {
			// 默认格式
			pattern = "yyyyMMddHHmmss";
		}

		// 格式化时间
		try {
			DateFormat df = new SimpleDateFormat(pattern);
			formatString = df.format(cal.getTime());
		} catch (Throwable t) {
			// pattern不符合规定
			logger.error("pattern of format date is invalid", t);
		}

		// 返回格式化的字符串
		return formatString;
	}

 
 
	// 日期相减精确到天数
	public static String getDaysNum(String data1, String data2) {
		String d1 = data1;
		String d2 = data2;
		String num = null;
		DateFormat df = new SimpleDateFormat("yyyyMMdd");
		try {
			Date dd1 = df.parse(d1);
			Date dd2 = df.parse(d2);
			long day1 = dd1.getTime();
			long day2 = dd2.getTime();
			num = String.valueOf((day2 - day1) / (1000 * 3600 * 24));
		} catch (ParseException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return num;
	}

	/**
	 * 检查字符串是否是合法的生日类型 通过校验，返回一个整数，正确返回1，否则返回0
	 * 
	 * @param value
	 * @return int
	 */
	public static int checkBirth(String value) {
		int returnValue = 1;
		String str1 = value.substring(0, 2);
		String str2 = value.substring(2, 3);
		String str3 = value.substring(3, 5);
		if (checkInt(str1) == null) {
			returnValue = 0;
		}
		if (!str2.equals("-")) {
			returnValue = 0;
		}
		if (checkInt(str3) == null) {
			returnValue = 0;
		}
		return returnValue;
	}

	/**
	 * 格式为yyyyMMdd转化成为yyyy-MM-dd格式类型 格式为yyyyMMddhhMMss转化成为yyyy-MM-dd-hh:MM:ss类型
	 * 
	 * @param str
	 * @return
	 */
	public static String chageType(String str) {

		// System.out.println("============================="+str);
		// 如果日期为空返回--
		if (StringUtil.isNull(str)) {
			return "--";
		}
		// 如果日期格式即不是8位也不是14位返回当前格式
		if (!StringUtil.isNull(str) && str.length() != 8 && str.length() != 14) {
			return str;
		}
		String num = "";
		DateFormat df = null;
		if (!str.equals("") && str.length() == 14) {
			df = new SimpleDateFormat("yyyyMMddHHmmss");
		}
		if (!str.equals("") && str.length() == 8) {
			df = new SimpleDateFormat("yyyyMMdd");
		}
		try {
			Date date = df.parse(str);
			if (!str.equals("") && str.length() == 14) {
				df = new SimpleDateFormat("yyyy-MM-dd-HH:mm:ss");
			}
			if (!str.equals("") && str.length() == 8) {
				df = new SimpleDateFormat("yyyy-MM-dd");
			}
			num = df.format(date);
		} catch (Throwable e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return num;
	}

	/**
	 * 格式为yyyyMMdd转化成为yyyy-MM-dd格式类型 格式为yyyyMMddhhMMss转化成为yyyy-MM-dd-hh:MM:ss类型
	 * 
	 * @param str
	 * @return
	 */
	public static String getShowString(Date date) {
		if (date == null) {
			return "--";
		}
		String num = "";
		DateFormat df = new SimpleDateFormat("yyyy-MM-dd");
		try {
			num = df.format(date);
		} catch (Throwable e) {
			e.printStackTrace();
		}
		return num;
	}
	
	/**
	 * 格式为yyyyMMdd转化成为yyyy-MM-dd格式类型 格式为yyyyMMddhhMMss转化成为yyyy-MM-dd-hh:MM:ss类型
	 * 
	 * @param str
	 * @return
	 */
	public static String getShowStringLong(Date date) {
		if (date == null) {
			return "--";
		}
		String num = "";
		DateFormat df = new SimpleDateFormat("yyyy-MM-dd hh:MM:ss");
		try {
			num = df.format(date);
		} catch (Throwable e) {
			e.printStackTrace();
		}
		return num;
	}
	
	/**
	 * 格式为yyyyMMdd转化成为yyyyMMdd格式类型 格式为yyyyMMddhhMMss转化成为yyyy-MM-dd-hh:MM:ss类型
	 * 
	 * @param str
	 * @return
	 */
	public static String getShowString2(Date date) {
		if (date == null) {
			return "--";
		}
		String num = "";
		DateFormat df = new SimpleDateFormat("yyyyMMdd");
		try {
			num = df.format(date);
		} catch (Throwable e) {
			e.printStackTrace();
		}
		return num;
	}
	
	/**
	 * 格式为yyyy-MM-dd HH:mm:ss的字符串,转化成Date数据类型
	 * 
	 * @param str
	 * @return
	 */
	public static Date getDateByStringl(String date) {
		if (StringUtil.isNull(date)||date.equals("--")) {
			return new Date();
		}
		Date num = new Date();
		DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		try {
			num = df.parse(date);
		} catch (Throwable e) {
			e.printStackTrace();
		}
		return num;
	}
	/**
	 * 格式为yyyy-MM-dd 的字符串,转化成Date数据类型
	 * 
	 * @param str
	 * @return
	 */
	
	public static Date getDateByString2(String date) {
		if (StringUtil.isNull(date)||date.equals("--")) {
			return new Date();
		}
		Date num = new Date();
		DateFormat df = new SimpleDateFormat("yyyy-MM-dd");
		try {
			num = df.parse(date);
		} catch (Throwable e) {
			e.printStackTrace();
		}
		return num;
	}
	
	
	/**
	 * 格式为yyyy-MM-dd的字符串,转化成Date数据类型
	 * 
	 * @param str
	 * @return
	 */
	public static Date getDateByStringBegin(String date) {
		if (StringUtil.isNull(date)) {
			return new Date();
		}
		if(date.trim().length()==10){
			date = date.trim() + " 00:00:00";
		}
		Date num = new Date();
		DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		try {
			num = df.parse(date);
		} catch (Throwable e) {
			e.printStackTrace();
		}
		return num;
	}
	/**
	 * 格式为yyyy-MM-dd的字符串,转化成Date数据类型
	 * 
	 * @param str
	 * @return
	 */
	public static Date getDateByStringEnd(String date) {
		if (StringUtil.isNull(date)) {
			return new Date();
		}
		if(date.trim().length()==10){
			date = date.trim();
		}
		Date num = new Date();
		DateFormat df = new SimpleDateFormat("yyyy-MM-dd");
		try {
			df.parse(date);
			Calendar c = df.getCalendar();
			c.add(Calendar.DAY_OF_YEAR, 1);
			num = c.getTime();
		} catch (Throwable e) {
			e.printStackTrace();
		}
		return num;
	}
	
	/**
	 * 判断一个字符串是否是空串
	 * @param str
	 * @return boolean
	 * @author 王明龙
	 */
	public static boolean isEmpty(Object object) {
		if (object==null){
			return true;
		}
		if (object instanceof String){
			return object.toString().equals("");
		}
		if (object instanceof Long){
			return ((Long)object).equals(0L);
		}else{
			return false;
		}
		
	}
	
	public static void main(String[] args){
		try {
			System.out.println(ValidateUtil.compare("20091101", "20091101"));
		}
		catch (ParseException e) {
			// TODO 自动生成 catch 块
			e.printStackTrace();
		}
	}
	
}
